/* eslint-disable object-curly-newline,prefer-destructuring */

/* 用于存放业务逻辑 */
import moment from 'moment';
import * as config from '../../utils/config';
import * as utils from '../../utils/utils'; /* 通用方法 */
import imgCheck from '../../assets/haveChecked.png'; /* 已审核ICON */
import imgInvalid from '../../assets/haveCancel.png'; /* 已作废ICON */


const dateFormat = 'YYYY-MM-DD HH:mm:ss'; /* 日期控件显示格式 */

/** ------------------  查看业务 ------------------ */
/**   查看单据时需要执行的业务   */
export function viewBillBusiness(props) {
  /*   添加从表数据中的handleType='update'   */
  props = addSlaveDataHandleTypeUpdate(props);
  /*   添加合计   */
  props = handleAddDataTotal(props);
  /*   渲染处理   */
  props = viewBillBusinessRender(props);
  /*   返回值   */
  return props;
}

/*   添加从表数据中的handleType='update'   */
export function addSlaveDataHandleTypeUpdate(props) {
  const { slaveData, copyToData } = props;
  if (utils.isNotEmptyArr(slaveData)) {
    for (const each of slaveData) {
      if (utils.isEmptyObject(copyToData)) {
        each.handleType = 'update';
      } else {
        each.handleType = 'add';
        each.bIsChange = true;
      }
    }
  }
  return props;
}

/*   渲染处理   */
export function viewBillBusinessRender(props) {
  props.editTableRender = true;
  props.showRender = [];
  props.showSlaveRender = {};
  /*   返回值   */
  return props;
}

/**   合计   */
export function handleAddDataTotal(props) {
  /*   dataTotal:后台传来的需要统计的列,slaveColumn:表头对象   */
  const { slaveColumn, slaveShowConfig, copyToData } = props;
  let { dataTotal } = props;
  /*   从表数据   */
  const { slaveData } = props;
  /*   是否需要统计   */
  const isNeed = props.isNeed || utils.isNotEmptyObject(copyToData);
  /*   把合计列先从从表中剔除掉,避免重复计算   */
  const slaveDataNoTotal = slaveData.filter(item => !item.dataTotal);
  /*   合计列单独取出   */
  const dataTotalData = getDataTotalBySlaveData(slaveData);
  /*   重新赋值dataTotal(新增有可能没合计列,所以需要从配置中重新统计)   */
  dataTotal = reAssignmentDataTotal(dataTotal, slaveShowConfig);
  /*   执行条件   */
  if (
    utils.isNotEmptyArr(slaveColumn) &&
    utils.isNotEmptyObject(dataTotal) &&
    utils.isNotEmptyArr(slaveDataNoTotal)
  ) {
    /*   获取合计对象   */
    const totalObj = getTotalObj(slaveColumn, slaveDataNoTotal, dataTotal, isNeed);
    /*   如果原来就存在合计列,那就把原来的合计列的key和sid付给新的合计对象   */
    if (utils.isNotEmptyObject(dataTotalData) && utils.isNotEmptyStr(dataTotalData.sId) && utils.isNotEmptyObject(totalObj)) {
      totalObj.sId = dataTotalData.sId;
      totalObj.key = dataTotalData.sId;
    }
    /*   添加合计对象   */
    slaveDataNoTotal.push(totalObj);
  }
  /*   返回值赋值   */
  props.slaveData = slaveDataNoTotal;
  props.isNeed = true;
  /*   合计渲染   */
  props = handleAddDataTotalRender(props);
  /*   返回值   */
  return props;
}

export function reAssignmentDataTotal(dataTotal, slaveShowConfig) {
  if (utils.isNotEmptyObject(dataTotal)) {
    return dataTotal;
  }
  if (utils.isNotEmptyObject(slaveShowConfig)) {
    const obj = {};
    for (const each of slaveShowConfig) {
      if (each.bSum) {
        obj[each.sName] = 0;
      }
    }
    return obj;
  }
}

/**   添加合计渲染   */
export function handleAddDataTotalRender(props) {
  /*   待用数据赋值   */
  const { slaveData, slaveShowConfig } = props;
  let { dataTotal, showSlaveRender } = props;
  /*   执行条件   */
  if (utils.isNotEmptyArr(slaveData)) {
    /*   过滤出合计行   */
    const slaveDataTotal = slaveData.filter(item => item.dataTotal)[0];
    /*   渲染对象   */
    const obj = {};
    /*   给合计列的渲染对象都赋值为true   */
    if (utils.isNotEmptyObject(slaveDataTotal)) {
      /*   重新赋值dataTotal(新增有可能没合计列,所以需要从配置中重新统计)   */
      dataTotal = reAssignmentDataTotal(dataTotal, slaveShowConfig);
      /*   遍历合计项的每一个key   */
      for (const key of Object.keys(slaveDataTotal)) {
        obj[key] = utils.isNotUndefined(dataTotal[key]);
      }
      /*   如果props的渲染对象是undefined,那默认给一个空对象   */
      if (utils.isUndefined(showSlaveRender)) {
        showSlaveRender = {};
      }
      /*   返回值赋值   */
      showSlaveRender[slaveDataTotal.sId] = obj;
      props.showSlaveRender = showSlaveRender;
    }
  }
  /*   返回值   */
  return props;
}

/**   从从表数据中获取合计列   */
export function getDataTotalBySlaveData(slaveData) {
  const dataTotalData = slaveData.filter(item => item.dataTotal);
  if (utils.isNotEmptyArr(dataTotalData)) {
    return dataTotalData[0];
  }
  return {};
}

/**   获取合计对象   */
export function getTotalObj(headerConfig, slaveData, dataTotal, isNeed) {
  /*   待用数据声明   */
  const sId = utils.createSid(); /*   唯一标示   */
  const totalObj = {
    dataTotal: true,
    key: sId,
    sId,
  };/*   统计对象的必须数据   */
  /*   遍历表头   */
  for (const headerConfigEach of headerConfig) {
    /*   获取sName   */
    const sName = headerConfigEach.dataIndex;
    /*   给合计对象添加属性和值   */
    totalObj[sName] = getStatisticsValue(sName, slaveData, dataTotal, isNeed);
  }
  /*   返回值   */
  return totalObj;
}

/**   获取统计值   */
export function getStatisticsValue(sName, slaveData, dataTotal, isNeed) {
  /*   返回值声明   */
  let res = '';
  /*   过滤出需要统计的列   */
  if (utils.isNotUndefined(dataTotal[sName])) {
    /*   判断是否需要统计(需要统计的话要遍历从表,不需要的话就直接取dataTotal中的数据)   */
    if (isNeed) { /*   把需要统计的列sum起来   */
      for (const each of slaveData) {
        res = utils.convertStrToNumber0(res) + utils.convertStrToNumber0(each[sName]);
      }
    } else { /*   不需要的统计的话直接取dataTotal中的值   */
      res = dataTotal[sName];
    }
  }
  /*   返回值   */
  return res;
}

/** ------------------  主表 ------------------ */

/**  更改主表数据  */
export function getChangeProps(props) {
  props = this.getRenderData(props); /* 下拉回带 */
  const { sModelsId } = props;
  const key = this.getChangeSName(props);
  const obj = { decimals: props.app.decimals };
  if (config.pageData[sModelsId].startsWith('sales')) {
    obj.sName = 'Product';
    if (key === 'sCustomerId' || key === 'sGetPayId' || key === 'tDeliverDate') {
      /* 结算日期 */
      props = this.getGeyPayDate(props);
    }
    /*   销售订单的特殊处理   */
    if (config.pageData[sModelsId] === 'salesOrder') {
      /*   销售订单交货日期带到从表中去   */
      if (key === 'tDeliverDate') {
        props = saleOrderDeliveDataFromMasterToSlave(props);
      }
      /*   销售订单的主表客户名称改变时从表的印件分类也都需要做相应的处理的渲染处理   */
      if (key === 'sCustomerId') {
        props = setSaleSlaveProductIdRenderByMasterCustomerId(props);
      }
    } else if (config.pageData[sModelsId] === 'salesDeliver') { /*   销售送货单的特殊处理   */
      if (key === 'sWareHouseId') {
        props = saleDeliverWareHouseIdFromMasterToSlave(props);
      }
    }
  }
  if (key === 'dCurrencyRate' || key === 'sCurrency' || key === 'sCustomerId') {
    props = this.getCalculateByCurrencyRate(props, obj);
  }
  /*   处理从表   */
  return props;
}

/**   销售订单交货日期带到从表中去   */
export function saleOrderDeliveDataFromMasterToSlave(props) {
  /*   处理数据   */
  props = saleOrderDeliveDataFromMasterToSlaveData(props);
  /*   处理渲染   */
  props = saleOrderDeliveDataFromMasterToSlaveRender(props);
  /*   返回值   */
  return props;
}

/**   销售订单交货日期带到从表中去(数据处理)   */
export function saleOrderDeliveDataFromMasterToSlaveRender(props) {
  /*   待用数据声明   */
  const { slaveData } = props;
  /*   待用数据声明   */
  const showSlaveRender = utils.isEmptyObject(props.showSlaveRender) ? {} : props.showSlaveRender;
  /*   执行条件   */
  if (utils.isNotEmptyArr(slaveData)) {
    /*   遍历从表数据   */
    for (const each of slaveData) {
      /*   把不是合计行的从表行中的tDeliverDate都置为true(不存在的这个行则创建一行)   */
      if (!each.dataTotal && utils.isNotEmptyStr(each.sId)) {
        const obj = utils.isEmptyObject(showSlaveRender[each.sId]) ? {} : showSlaveRender[each.sId];
        obj.tDeliverDate = true;
        showSlaveRender[each.sId] = obj;
      }
    }
  }
  /*   返回值赋值   */
  props.showSlaveRender = showSlaveRender;
  props.editTableRender = true;
  /*   返回值   */
  return props;
}

/**   销售订单交货日期带到从表中去(数据处理)   */
export function saleOrderDeliveDataFromMasterToSlaveData(props) {
  /*   待用数据声明   */
  const { slaveData, masterData } = props;
  /*   从表有数据继续玩下去   */
  if (utils.isNotEmptyArr(slaveData)) {
    /*   遍历从表数据,把不是合计项的从表行的tDeliverDate的值都变成主表的tDeliverDate值   */
    for (const each of slaveData) {
      if (!each.dataTotal) {
        if (typeof masterData.tDeliverDate === 'object') {
          each.tDeliverDate = masterData.tDeliverDate;
        } else {
          each.tDeliverDate = moment(masterData.tDeliverDate);
        }
      }
    }
  }
  /*   返回值   */
  return props;
}

/**   销售送货单仓库名称带到从表中去   */
export function saleDeliverWareHouseIdFromMasterToSlave(props) {
  /*   处理数据   */
  props = saleDeliverWareHouseIdFromMasterToSlaveData(props);
  /*   处理渲染   */
  props = saleDeliverWareHouseIdFromMasterToSlaveRender(props);
  /*   返回值   */
  return props;
}

/**   销售送货单仓库名称带到从表中去(数据处理)   */
export function saleDeliverWareHouseIdFromMasterToSlaveData(props) {
  /*   待用数据声明   */
  const { slaveData, masterData } = props;
  /*   从表有数据继续玩下去   */
  if (utils.isNotEmptyArr(slaveData)) {
    /*   遍历从表数据,把不是合计项的从表行的sWareHouseId的值都变成主表的sWareHouseId值   */
    for (const each of slaveData) {
      if (!each.dataTotal) {
        each.sWareHouseId = masterData.sWareHouseId;
      }
    }
  }
  /*   返回值   */
  return props;
}

/**   销售送货单仓库名称带到从表中去(数据处理)   */
export function saleDeliverWareHouseIdFromMasterToSlaveRender(props) {
  /*   待用数据声明   */
  const { slaveData } = props;
  /*   待用数据声明   */
  const showSlaveRender = utils.isEmptyObject(props.showSlaveRender) ? {} : props.showSlaveRender;
  /*   执行条件   */
  if (utils.isNotEmptyArr(slaveData)) {
    /*   遍历从表数据   */
    for (const each of slaveData) {
      /*   把不是合计行的从表行中的sWareHouseId都置为true(不存在的这个行则创建一行)   */
      if (!each.dataTotal && utils.isNotEmptyStr(each.sId)) {
        const obj = utils.isEmptyObject(showSlaveRender[each.sId]) ? {} : showSlaveRender[each.sId];
        obj.sWareHouseId = true;
        showSlaveRender[each.sId] = obj;
      }
    }
  }
  /*   返回值赋值   */
  props.showSlaveRender = showSlaveRender;
  props.editTableRender = true;
  /*   返回值   */
  return props;
}

/**   销售订单客户名称发生改变时设置从表印件名称重新渲染   */
export function setSaleSlaveProductIdRenderByMasterCustomerId(props) {
  /*   待用数据声明   */
  const { slaveData } = props;
  const showSlaveRender = utils.isEmptyObject(props.showSlaveRender) ? {} : props.showSlaveRender;
  /*   执行条件   */
  if (utils.isNotEmptyArr(slaveData)) {
    /*   遍历从表数据   */
    for (const each of slaveData) {
      /*   存在印件和从表编号才执行下面的动作   */
      if (utils.isNotEmptyStr(each.sId)) {
        /*   添加所有行的都有一个sProductId   */
        showSlaveRender[each.sId] = { sProductId: true };
      }
    }
  }
  /*   返回值赋值   */
  props.editTableRender = true;
  props.showSlaveRender = showSlaveRender;
  /*   返回值   */
  return props;
}

/**   获取发生改变的列名   */
export function getChangeSName(props) {
  let res = '';
  const { changeValue } = props;
  if (utils.isNotEmptyObject(changeValue)) {
    res = Object.keys(changeValue)[0];
  }
  return res;
}

/** 根据配置，获取相应的值 */
export function getRenderData(props) {
  const key = this.getChangeSName(props);
  const showRender = [key];
  const { masterShowConfig, masterData } = props;
  const changeConfig = masterShowConfig.filter(item => item.sName === key)[0]; /* 配置 */
  const changeData = getChangeData(props); /* 具体某条值 */
  if (utils.isNotEmptyObject(changeData)) {
    const { sAssignField } = changeConfig;
    if (sAssignField !== '') {
      /* 赋值数组 */
      const sAssignFieldObj = sAssignField.split(',');
      for (const child of sAssignFieldObj) {
        const childSplit = child.split(':');
        masterData[childSplit[0]] = changeData[childSplit[1]];
        const index = showRender.findIndex(item => item === childSplit[0]); /* 排队重复值 */
        if (index === -1) {
          showRender.push(childSplit[0]);
        }
      }
    }
  }
  props.showRender = [...showRender];
  return props;
}

/** 获取当前下拉的值和相关数据 */
export function getChangeData(props) {
  const { changeValue, masterSelectAllValue } = props;
  const key = Object.keys(changeValue)[0];
  let changeData = {};
  const changeListData = masterSelectAllValue[key]; /* 下拉列表数据 */
  if (changeListData !== undefined) {
    [changeData] = changeListData.filter(item => item.sId === changeValue[key]);
  }
  return changeData;
}

/** 结算日期计算 */
export function getGeyPayDate(props) {
  let { masterData } = props;
  const { showRender } = props;
  const changeData = this.getChangeData(props); /* 具体某条值 */
  masterData = { ...masterData, ...changeData, sId: masterData.sId };
  const { tCreateDate, tDeliverDate, sGetPayType, iMonth, iDay, iAfterDeliverDay } = masterData;
  const tCreateDateValue = tCreateDate !== undefined && tCreateDate !== null ? moment(tCreateDate).format(dateFormat) : moment().format(dateFormat);
  const tDeliverDateValue = tDeliverDate !== undefined && tDeliverDate !== null ? moment(tDeliverDate).format(dateFormat) : tCreateDateValue;
  let tGetPayDate = '';
  if (utils.isNotUndefined(sGetPayType)) {
    if (sGetPayType === 'now') {
      tGetPayDate = tCreateDateValue;
    } else if (sGetPayType === 'month') {
      const tCreateValue = moment(tCreateDate).set('date', iDay); /* 需要设置的Day */
      tGetPayDate = moment(tCreateValue).add(iMonth, 'months').format(dateFormat);
      const tCurrentDay = moment(tCreateDate).get('date'); /* 当前Day */
      if (tCurrentDay <= iDay) {
        tGetPayDate = moment(tGetPayDate).format(dateFormat);
      } else {
        tGetPayDate = moment(tGetPayDate).add(1, 'months').format(dateFormat);
      }
    } else if (sGetPayType === 'deliver') {
      tGetPayDate = moment(tDeliverDateValue).add(iAfterDeliverDay, 'days').format(dateFormat);
    }
    masterData.tGetPayDate = tGetPayDate;
    showRender.push('tGetPayDate');
    props = { ...props, showRender, masterData };
  }
  return props;
}

/** ------------------  从表 ------------------ */

/**   处理从表数据变更   */
export function handleSlaveChange(props) {
  /*   从表数据变更  */
  props = this.getSlaveRenderData(props);
  /*   待用数据声明   */
  const { sModelsId } = props;
  const obj = { decimals: props.app.decimals };
  /*   销售订单的特殊处理   */
  if (config.pageData[sModelsId].startsWith('sales')) {
    obj.sName = 'Product';
    if (config.pageData[sModelsId] === 'salesDeliver') {
      /* 箱包计算 */
      props = this.getCalculateBag(props, obj);
    }
  }
  /* 各种金额，税额，价格计算 */
  props = this.getCalculateAllMoney(props, obj);
  /*   重新合计  */
  props = this.handleAddDataTotal(props);
  /*   返回值  */
  return props;
}

/** 根据配置，获取相应的值 */
export function getSlaveRenderData(props) {
  const { changeValue, sId, masterData, slaveShowConfig, slaveData } = props;
  const key = Object.keys(changeValue)[0];
  const showSlaveRender = {};
  showSlaveRender[sId] = { [key]: true };
  const index = slaveData.findIndex(item => item.sId === sId);
  slaveData[index][key] = changeValue[key]; /* 从表普通赋值 */
  slaveData[index].bIsChange = true; /*   标识这条数据有过改动   */
  const changeConfig = slaveShowConfig.filter(item => item.sName === key)[0]; /* 配置 */
  const changeData = getChangeSlaveData(props); /* 具体某条值 */
  if (utils.isNotEmptyObject(changeData)) {
    const { sAssignField } = changeConfig;
    if (sAssignField !== '') {
      /* 从表下拉回带赋值 */
      const sAssignFieldObj = sAssignField.split(',');
      for (const child of sAssignFieldObj) {
        const childSplit = child.split(':');
        const changeChild = slaveData[index];
        if (childSplit[1].indexOf('#') === -1) { /* #代表要取主表里面的值 */
          changeChild[childSplit[0]] = changeData[childSplit[1]];
        } else {
          changeChild[childSplit[0]] = masterData[childSplit[0]];
        }
        showSlaveRender[sId][childSplit[0]] = true;
      }
    }
  }
  props.showSlaveRender = { ...showSlaveRender };
  return props;
}

/** 获取当前从表下拉的值和相关数据 */
export function getChangeSlaveData(props) {
  const { changeValue, sId, slaveSelectAllValue } = props;
  const key = Object.keys(changeValue)[0];
  let changeData = {};
  const changeList = slaveSelectAllValue[sId]; /* 那一行的下拉数据 */
  const changeListData = changeList[key];
  if (changeListData !== undefined) {
    [changeData] = changeListData.filter(item => item.sId === changeValue[key]);
  }
  return changeData;
}
/** ------------------  新增行start ------------------ */

/**   新增行业务   */
export function doAddRowBusiness(addSlaveRow, props, message) {
  /*   返回值   */
  const { sModelsId } = props;
  /*   销售业务   */
  if (config.pageData[sModelsId].startsWith('sales')) {
    const { masterData } = props;
    /*   客户名称为空时不允许增加行   */
    addSlaveRow = doAddRowBusinessSales(addSlaveRow, props, message);
    if (utils.isEmptyObject(addSlaveRow)) return addSlaveRow;
    /*   税率和税率id带到从表   */
    addSlaveRow = changeSlaveTaxRateTaxIdByMaster(masterData, addSlaveRow);
    /*   销售订单业务   */
    if (config.pageData[sModelsId] === 'salesOrder') {
      return doAddRowBusinessSalesOrder(addSlaveRow, props);
    }
    /*   销售送货单业务   */
    if (config.pageData[sModelsId] === 'salesDeliver') {
      return doAddRowBusinessSalesDeliver(addSlaveRow, props);
    }
  }
  /*   返回值   */
  return addSlaveRow;
}

/**   新增行业务(销售业务)   */
export function doAddRowBusinessSales(addSlaveRow, props, message) {
  /*   返回值声明   */
  const { masterData, masterShowConfig } = props;
  /*   客户名称为空时不允许增加行   */
  if (utils.isEmptyObject(masterData) || utils.isEmptyStr(masterData.sCustomerId)) {
    const { showName } = masterShowConfig.filter(item => (item.sName === 'sCustomerId'))[0];
    message.warn(`${showName}不能为空!`);
    return {};
  }
  /*   返回值   */
  return addSlaveRow;
}

/**   新增行业务(销售订单业务)   */
export function doAddRowBusinessSalesOrder(addSlaveRow, props) {
  /*   返回值声明   */
  const { masterData } = props;
  /*   执行条件   */
  if (
    utils.isNotEmptyObject(masterData) &&
    utils.isNotEmptyObject(addSlaveRow)
  ) {
    /*   交货日期带到从表   */
    addSlaveRow = changeSlaveDeliverDateByMaster(masterData, addSlaveRow);
  }
  /*   返回值   */
  return addSlaveRow;
}

/**   新增行业务(销售送货单单业务)   */
export function doAddRowBusinessSalesDeliver(addSlaveRow, props) {
  /*   返回值声明   */
  const { masterData } = props;
  /*   执行条件   */
  if (
    utils.isNotEmptyObject(masterData) &&
    utils.isNotEmptyObject(addSlaveRow)
  ) {
    addSlaveRow = changeSlaveWareHouseIdByMaster(masterData, addSlaveRow);
  }
  /*   返回值   */
  return addSlaveRow;
}

/**   通过主表交货日期变更从表交货日期   */
export function changeSlaveDeliverDateByMaster(masterData, addSlaveRow) {
  if (utils.isUndefinedNull(masterData.tDeliverDate)) {
    addSlaveRow.tDeliverDate = null;
  } else if (typeof masterData.tDeliverDate === 'object') {
    addSlaveRow.tDeliverDate = masterData.tDeliverDate;
  } else {
    addSlaveRow.tDeliverDate = moment(masterData.tDeliverDate);
  }
  return addSlaveRow;
}

/**   通过主表仓库名称变更从表仓库名称   */
export function changeSlaveWareHouseIdByMaster(masterData, addSlaveRow) {
  if (utils.isUndefined(masterData.sWareHouseId)) {
    addSlaveRow.sWareHouseId = '';
  } else {
    addSlaveRow.sWareHouseId = masterData.sWareHouseId;
  }
  return addSlaveRow;
}

/**   通过主表税率和税率id变更从表税率及税率id   */
export function changeSlaveTaxRateTaxIdByMaster(masterData, addSlaveRow) {
  addSlaveRow.dTaxRate = getMasterTaxRate(masterData);
  addSlaveRow.sTaxId = getMasterTaxId(masterData);
  return addSlaveRow;
}

/**   获取主表税率   */
export function getMasterTaxRate(masterData) {
  /*   返回值声明   */
  let taxRate = 0;
  /*   主表数据存在病情不是undefined的时候返回主表数据的税率值   */
  if (utils.isNotEmptyObject(masterData) && utils.isNotUndefined(masterData.dTaxRate)) {
    taxRate = masterData.dTaxRate;
  }
  /*   返回值   */
  return taxRate;
}

/**   获取主表税率id   */
export function getMasterTaxId(masterData) {
  /*   返回值声明   */
  let taxId = '';
  /*   主表数据存在病情不是undefined的时候返回主表数据的税率值   */
  if (
    utils.isNotEmptyObject(masterData) &&
    utils.isNotEmptyStr(masterData.sTaxId)) {
    taxId = masterData.sTaxId;
  }
  /*   返回值   */
  return taxId;
}

/** ------------------  新增行end ------------------ */


/** 汇率计算 */
export function getCalculateByCurrencyRate(props, obj) {
  const { slaveData } = props;
  const { sName } = obj;
  const showSlaveRender = {};
  for (const item of slaveData) {
    if (!item.dataTotal) {
      this.getResultByCurrencyRate(item, props, obj);
      const { sId } = item;
      showSlaveRender[sId] = { [`d${sName}ForeignMoney`]: true, [`d${sName}TaxForeignMoney`]: true };
    }
  }
  props.showSlaveRender = showSlaveRender;
  props.editTableRender = true;
  props = this.handleAddDataTotal(props);
  return props;
}

/** 外币金额，外币税额计算 */
export function getResultByCurrencyRate(item, props, obj) {
  const { sName, decimals } = obj;
  const { dNetMoney } = decimals;
  const { masterData } = props;
  if (utils.isNum(item[`d${sName}Money`]) && utils.isNum(item[`d${sName}TaxMoney`]) && utils.isNum(masterData.dCurrencyRate)) {
    const dProductMoney = utils.parseFloatNum(item[`d${sName}Money`]);
    const dProductTaxMoney = utils.parseFloatNum(item[`d${sName}TaxMoney`]);
    const dCurrencyRate = utils.parseFloatNum(masterData.dCurrencyRate);
    const dProductForeignMoney = dCurrencyRate !== 0 ? dProductMoney / dCurrencyRate : 0;
    /* 外币金额 */
    const dProductTaxForeignMoney = dCurrencyRate !== 0 ? dProductTaxMoney / dCurrencyRate : 0;
    /* 外币税额 */
    item[`d${sName}ForeignMoney`] = utils.convertFixNum(dProductForeignMoney, dNetMoney);
    item[`d${sName}TaxForeignMoney`] = utils.convertFixNum(dProductTaxForeignMoney, dNetMoney);
  }
}

/**   主表对于disabled的处理   */
export function dealMasterDisabled(props) {
  /*   待用数据声明   */
  const { sModelsId, masterShowConfig, slaveData, isMasterRender } = props;
  /*   执行条件   */
  if (utils.isNotEmptyArr(masterShowConfig)) {
    /*   遍历所有配置添加特殊控制(用于控制disabled)   */
    for (const showConfig of masterShowConfig) {
      /*   销售模块的从表不为空时sCustomerId不可编辑   */
      if (config.pageData[sModelsId] !== undefined && config.pageData[sModelsId].startsWith('sales')) {
        const oldSpecialControl = showConfig.specialControl;
        const newSpecialControl = showConfig.sName === 'sCustomerId' && utils.isNotEmptyArr(slaveData);
        if (oldSpecialControl !== newSpecialControl) {
          showConfig.specialControl = newSpecialControl;
          isMasterRender.sCustomerId = true;
        }
      }
    }
  }
  /*   返回值   */
  return props;
}

/** 获取当前从表行的值 */
export function getChangeSlaveItem(props) {
  const { sId, slaveData } = props; /* sId 为当前行的key */
  const index = slaveData.findIndex(item => item.sId === sId); /* 当前为第几行 */
  return slaveData[index];
}

/** 根据不同的模块，选出具体计算不同模块的计算方式等 */
export function getCalculateAllMoney(props, obj) {
  const key = this.getChangeSName(props);
  const { sName } = obj;
  if (key === `d${sName}Qty` || key === `d${sName}Price` || key === 'sTaxId') {
    props = this.getCalculateByPrice(props, obj);
    if (key === `d${sName}Price`) {
      props = this.getCalculatedLossMoney(props, obj);
    }
    if (key === `d${sName}Qty`) {
      props = this.getCalculatedReserveBags(props, obj);
    }
  }
  if (key === `d${sName}Money`) {
    props = this.getCalculateMoney(props, obj);
  }
  if (key === `d${sName}NoTaxPrice`) {
    props = this.getCalculateNoTaxPrice(props, obj);
  }
  if (key === `d${sName}NoTaxMoney`) {
    props = this.getCalculateNoTaxMoney(props, obj);
  }
  if (key === 'dLossQty') {
    props = this.getCalculatedLossMoney(props, obj);
  }
  return props;
}


/** 输入数量, 价格, 税码, 计算计算金额，不含税金额，不含税价格，税额，外币金额，外币税额 */
export function getCalculateByPrice(props, obj) {
  const { sId, showSlaveRender } = props;
  const item = this.getChangeSlaveItem(props);
  const { sName, decimals } = obj;
  const { masterData } = props;
  if (utils.isNum(item[`d${sName}Price`]) && utils.isNum(item[`d${sName}Qty`]) && utils.isNum(masterData.dCurrencyRate)) {
    const { dNetPrice, dNetMoney } = decimals;
    const dProductQty = utils.parseFloatNum(item[`d${sName}Qty`]); /* 数量 */
    const dProductPrice = utils.parseFloatNum(item[`d${sName}Price`]); /* 价格 */
    const dTaxRate = utils.parseFloatNum(item.dTaxRate); /* 税率 */
    const dCurrencyRate = utils.parseFloatNum(masterData.dCurrencyRate); /* 汇率 */
    const dProductMoney = dProductQty * dProductPrice; /* 金额 */
    const dProductNoTaxMoney = dProductMoney / (1 + (dTaxRate / 100)); /* 不含税金额 */
    const dProductNoTaxPrice = dProductQty !== 0 ? dProductNoTaxMoney / dProductQty : 0; /* 不含税价 */
    const dProductTaxMoney = dProductMoney - dProductNoTaxMoney; /* 税额 */
    const dProductForeignMoney = dCurrencyRate !== 0 ? dProductMoney / dCurrencyRate : 0; /* 外币金额 */
    const dProductTaxForeignMoney = dCurrencyRate !== 0 ? dProductTaxMoney / dCurrencyRate : 0; /* 外币税额 */
    item[`d${sName}Money`] = utils.convertFixNum(dProductMoney, dNetMoney);
    item[`d${sName}NoTaxMoney`] = utils.convertFixNum(dProductNoTaxMoney, dNetMoney);
    item[`d${sName}NoTaxPrice`] = utils.convertFixNum(dProductNoTaxPrice, dNetPrice);
    item[`d${sName}TaxMoney`] = utils.convertFixNum(dProductTaxMoney, dNetMoney);
    item[`d${sName}ForeignMoney`] = utils.convertFixNum(dProductForeignMoney, dNetMoney);
    item[`d${sName}TaxForeignMoney`] = utils.convertFixNum(dProductTaxForeignMoney, dNetMoney);
    showSlaveRender[sId] = {
      ...showSlaveRender[sId],
      [`d${sName}Money`]: true,
      [`d${sName}NoTaxMoney`]: true,
      [`d${sName}NoTaxPrice`]: true,
      [`d${sName}TaxMoney`]: true,
      [`d${sName}ForeignMoney`]: true,
      [`d${sName}TaxForeignMoney`]: true,
    };
  }
  props.showSlaveRender = showSlaveRender;
  props.editTableRender = true;
  return props;
}

/** 根据金额，具体计算价格，不含税金额，不含税价格，税额，外币金额，外币税额 */
export function getCalculateMoney(props, obj) {
  const { sId, showSlaveRender } = props;
  const item = this.getChangeSlaveItem(props);
  const { sName, decimals } = obj;
  const { masterData } = props;
  if (utils.isNum(item[`d${sName}Money`]) && utils.isNum(item[`d${sName}Qty`]) && utils.isNum(masterData.dCurrencyRate)) {
    const { dNetPrice, dNetMoney } = decimals;
    const dProductQty = utils.parseFloatNum(item[`d${sName}Qty`]); /* 数量 */
    const dProductMoney = utils.parseFloatNum(item[`d${sName}Money`]); /* 金额 */
    const dTaxRate = utils.parseFloatNum(item.dTaxRate); /* 税率 */
    const dCurrencyRate = utils.parseFloatNum(masterData.dCurrencyRate); /* 汇率 */
    const dProductPrice = dProductQty !== 0 ? dProductMoney / dProductQty : 0; /* 价格 */
    const dProductNoTaxMoney = dProductMoney / (1 + (dTaxRate / 100)); /* 不含税金额 */
    const dProductNoTaxPrice = dProductQty !== 0 ? dProductNoTaxMoney / dProductQty : 0; /* 不含税价 */
    const dProductTaxMoney = dProductMoney - dProductNoTaxMoney; /* 税额 */
    const dProductForeignMoney = dCurrencyRate !== 0 ? dProductMoney / dCurrencyRate : 0; /* 外币金额 */
    const dProductTaxForeignMoney = dCurrencyRate !== 0 ? dProductTaxMoney / dCurrencyRate : 0; /* 外币税额 */
    item[`d${sName}Price`] = utils.convertFixNum(dProductPrice, dNetPrice);
    item[`d${sName}NoTaxMoney`] = utils.convertFixNum(dProductNoTaxMoney, dNetMoney);
    item[`d${sName}NoTaxPrice`] = utils.convertFixNum(dProductNoTaxPrice, dNetPrice);
    item[`d${sName}TaxMoney`] = utils.convertFixNum(dProductTaxMoney, dNetMoney);
    item[`d${sName}ForeignMoney`] = utils.convertFixNum(dProductForeignMoney, dNetMoney);
    item[`d${sName}TaxForeignMoney`] = utils.convertFixNum(dProductTaxForeignMoney, dNetMoney);
    showSlaveRender[sId] = {
      ...showSlaveRender[sId],
      [`d${sName}Price`]: true,
      [`d${sName}NoTaxMoney`]: true,
      [`d${sName}NoTaxPrice`]: true,
      [`d${sName}TaxMoney`]: true,
      [`d${sName}ForeignMoney`]: true,
      [`d${sName}TaxForeignMoney`]: true,
    };
  }
  props.showSlaveRender = showSlaveRender;
  props.editTableRender = true;
  return props;
}

/** 输入不含税价格, 计算不含税金额，税额，金额，价格，外币金额，外币税额 */
export function getCalculateNoTaxPrice(props, obj) {
  const { sId, showSlaveRender } = props;
  const item = this.getChangeSlaveItem(props);
  const { sName, decimals } = obj;
  const { masterData } = props;
  if (utils.isNum(item[`d${sName}NoTaxPrice`]) && utils.isNum(item[`d${sName}Qty`]) && utils.isNum(masterData.dCurrencyRate)) {
    const { dNetPrice, dNetMoney } = decimals;
    const dProductQty = utils.parseFloatNum(item[`d${sName}Qty`]); /* 数量 */
    const dProductNoTaxPrice = utils.parseFloatNum(item[`d${sName}NoTaxPrice`]); /* 不含税价 */
    const dTaxRate = utils.parseFloatNum(item.dTaxRate); /* 税率 */
    const dCurrencyRate = utils.parseFloatNum(masterData.dCurrencyRate); /* 汇率 */
    const dProductNoTaxMoney = dProductQty * dProductNoTaxPrice; /* 不含税金额 */
    const dProductTaxMoney = dProductNoTaxMoney * (dTaxRate / 100); /* 税额 */
    const dProductMoney = dProductNoTaxMoney + dProductTaxMoney; /* 金额 */
    const dProductPrice = dProductQty !== 0 ? dProductMoney / dProductQty : 0; /* 价格 */
    const dProductForeignMoney = dCurrencyRate !== 0 ? dProductMoney / dCurrencyRate : 0; /* 外币金额 */
    const dProductTaxForeignMoney = dCurrencyRate !== 0 ? dProductTaxMoney / dCurrencyRate : 0; /* 外币税额 */
    item[`d${sName}NoTaxMoney`] = utils.convertFixNum(dProductNoTaxMoney, dNetMoney);
    item[`d${sName}TaxMoney`] = utils.convertFixNum(dProductTaxMoney, dNetMoney);
    item[`d${sName}Money`] = utils.convertFixNum(dProductMoney, dNetMoney);
    item[`d${sName}Price`] = utils.convertFixNum(dProductPrice, dNetPrice);
    item[`d${sName}ForeignMoney`] = utils.convertFixNum(dProductForeignMoney, dNetMoney);
    item[`d${sName}TaxForeignMoney`] = utils.convertFixNum(dProductTaxForeignMoney, dNetMoney);
    showSlaveRender[sId] = {
      ...showSlaveRender[sId],
      [`d${sName}NoTaxMoney`]: true,
      [`d${sName}TaxMoney`]: true,
      [`d${sName}Money`]: true,
      [`d${sName}Price`]: true,
      [`d${sName}ForeignMoney`]: true,
      [`d${sName}TaxForeignMoney`]: true,
    };
  }
  props.showSlaveRender = showSlaveRender;
  props.editTableRender = true;
  return props;
}

/** 输入不含税金额， 计算不含税价格，税额，金额，价格，外币金额，外币税额 */
export function getCalculateNoTaxMoney(props, obj) {
  const { sId, showSlaveRender } = props;
  const item = this.getChangeSlaveItem(props);
  const { sName, decimals } = obj;
  const { masterData } = props;
  if (utils.isNum(item[`d${sName}NoTaxMoney`]) && utils.isNum(item[`d${sName}Qty`]) && utils.isNum(masterData.dCurrencyRate)) {
    const { dNetPrice, dNetMoney } = decimals;
    const dProductQty = utils.parseFloatNum(item[`d${sName}Qty`]);
    const dProductNoTaxMoney = utils.parseFloatNum(item[`d${sName}NoTaxMoney`]);
    const dTaxRate = utils.parseFloatNum(item.dTaxRate);
    const dCurrencyRate = utils.parseFloatNum(masterData.dCurrencyRate);
    const dProductNoTaxPrice = dProductQty !== 0 ? dProductNoTaxMoney / dProductQty : 0; /* 不含税价格 */
    const dProductTaxMoney = dProductNoTaxMoney * (dTaxRate / 100); /* 税额 */
    const dProductMoney = dProductNoTaxMoney + dProductTaxMoney; /* 金额 */
    const dProductPrice = dProductQty !== 0 ? dProductMoney / dProductQty : 0; /* 价格 */
    const dProductForeignMoney = dCurrencyRate !== 0 ? dProductMoney / dCurrencyRate : 0; /* 外币金额 */
    const dProductTaxForeignMoney = dCurrencyRate !== 0 ? dProductTaxMoney / dCurrencyRate : 0; /* 外币税额 */
    item[`d${sName}NoTaxPrice`] = utils.convertFixNum(dProductNoTaxPrice, dNetPrice);
    item[`d${sName}TaxMoney`] = utils.convertFixNum(dProductTaxMoney, dNetMoney);
    item[`d${sName}Money`] = utils.convertFixNum(dProductMoney, dNetMoney);
    item[`d${sName}Price`] = utils.convertFixNum(dProductPrice, dNetPrice);
    item[`d${sName}ForeignMoney`] = utils.convertFixNum(dProductForeignMoney, dNetMoney);
    item[`d${sName}TaxForeignMoney`] = utils.convertFixNum(dProductTaxForeignMoney, dNetMoney);
    showSlaveRender[sId] = {
      ...showSlaveRender[sId],
      [`d${sName}NoTaxPrice`]: true,
      [`d${sName}TaxMoney`]: true,
      [`d${sName}Money`]: true,
      [`d${sName}Price`]: true,
      [`d${sName}ForeignMoney`]: true,
      [`d${sName}TaxForeignMoney`]: true,
    };
  }
  props.showSlaveRender = showSlaveRender;
  props.editTableRender = true;
  return props;
}

/** 输入报损数量 */
export function getCalculatedLossMoney(props, obj) {
  const { sId, showSlaveRender } = props;
  const item = this.getChangeSlaveItem(props);
  const { sName, decimals } = obj;
  if (utils.isNum(item.dLossQty) && utils.isNum(item[`d${sName}Price`])) {
    const { dNetMoney } = decimals;
    const dLossQty = utils.parseFloatNum(item.dLossQty); /* 报损换算数量 */
    const dProductPrice = utils.parseFloatNum(item[`d${sName}Price`]);
    const dLossMoney = dLossQty * dProductPrice;
    item.dLossMoney = utils.convertFixNum(dLossMoney, dNetMoney);
    showSlaveRender[sId] = {
      ...showSlaveRender[sId],
      dLossQty: true,
      dLossMoney: true,
      [`d${sName}Price`]: true,
    };
  }
  props.showSlaveRender = showSlaveRender;
  props.editTableRender = true;
  return props;
}

/** 输入数量/箱，包数，零头数量，计算数量 */
export function getCalculateBag(props, obj) {
  const key = this.getChangeSName(props);
  if (key === 'dPackQty' || key === 'dTrunkQty' || key === 'dFractionQty') {
    const { sId, showSlaveRender } = props;
    const item = this.getChangeSlaveItem(props);
    const { sName } = obj;
    if (utils.isNum(item.dPackQty) && utils.isNum(item.dFractionQty)) {
      const dPackQty = utils.parseFloatNum(item.dPackQty); /* 包数 */
      const dTrunkQty = utils.convertIsNotNumToNumber1(item.dTrunkQty); /* 数量/箱 */
      const dFractionQty = utils.parseFloatNum(item.dFractionQty); /* 零头数量 */
      const dProductQty = (dPackQty * dTrunkQty) + dFractionQty; /* 数量 */
      item.dTrunkQty = dTrunkQty;
      item[`d${sName}Qty`] = utils.convertStrToNumberUndefined(dProductQty);
      showSlaveRender[sId] = {
        ...showSlaveRender[sId],
        dTrunkQty: true,
        [`d${sName}Qty`]: true,
      };
    }
    props.showSlaveRender = showSlaveRender;
    props.editTableRender = true;
    props = this.getCalculateByPrice(props, obj); /* 根据数量，计算其他相关值 */
  }
  return props;
}

/** 输入数量, 计算箱包 */
export function getCalculatedReserveBags(props, obj) {
  const { sId, showSlaveRender } = props;
  const item = this.getChangeSlaveItem(props);
  const { sName } = obj;
  if (utils.isNum(item[`d${sName}Qty`])) {
    const dProductQty = utils.parseFloatNum(item[`d${sName}Qty`]); /* 数量 */
    const dTrunkQty = utils.convertIsNotNumToNumber1(item.dTrunkQty); /* 数量/箱 */
    const dPackQty = dTrunkQty !== 0 ? dProductQty / dTrunkQty : 0; /* 包数 */
    const dFractionQty = dTrunkQty !== 0 ? dProductQty - (dPackQty / dTrunkQty) : 0; /* 零头数量 */
    item.dPackQty = utils.convertStrToNumberUndefined(dPackQty);
    item.dFractionQty = utils.convertStrToNumberUndefined(dFractionQty);
    showSlaveRender[sId] = {
      ...showSlaveRender[sId],
      dPackQty: true,
      dFractionQty: true,
    };
  }
  props.showSlaveRender = showSlaveRender;
  props.editTableRender = true;
  return props;
}


/**   保存验证   */
export function handleSaveValidate(props) {
  /*   待用数据赋值   */
  const { masterData, gdsformconst, sModelsId, slaveData } = props;
  /*   审核订单不能保存   */
  props.saveError = '';
  if (masterData.bCheck) {
    props.saveError = gdsformconst.filter(item => (item.sName === 'sToExamineCheck'))[0].showName;
  }
  /*   销售订单从表不能为空   */
  if (config.pageData[sModelsId].startsWith('sales')) {
    if (utils.isEmptyArr(slaveData)) {
      props.saveError = '请输入从表信息';
    }
  }
  /*   返回值   */
  return props;
}

/**   保存主表数据   */
export function handleSaveMaster(masterSaveData, props) {
  const { sModelsId } = props;
  masterSaveData.sFormId = sModelsId;
  return masterSaveData;
}

/**   保存从表数据   */
export function handleSaveSlave(slaveSaveData, masterSaveData, props) {
  /*   待用数据赋值   */
  const { sModelsId } = props;
  slaveSaveData = handleSaveSlaveCommon(slaveSaveData, masterSaveData);
  /*   销售订单   */
  if (config.pageData[sModelsId] === 'salesOrder') {
    slaveSaveData = handleSaveSlaveSaleOrder(slaveSaveData);
  }
  /*   返回值   */
  return slaveSaveData;
}

/**   公共保存从表数据   */
export function handleSaveSlaveCommon(slaveSaveData, masterSaveData) {
  if (utils.isNotEmptyArr(slaveSaveData)) {
    for (const each of slaveSaveData) {
      each.sParentId = masterSaveData.sId;
    }
  }
  return slaveSaveData;
}

/**   销售订单保存从表数据   */
export function handleSaveSlaveSaleOrder(slaveSaveData) {
  if (utils.isNotEmptyArr(slaveSaveData)) {
    for (const each of slaveSaveData) {
      if (utils.isNotEmptyStr(each.sProductId)) {
        const sProductInfo = {
          sProductName: each.sProductName,
          sProductStyle: each.sProductStyle,
          sProductUnit: each.sProductUnit,
          sProductNo: '',
          sCustomerMaterialNo: '',
          sProductParentId: each.sParentClassify,
        };
        each.sProductInfo = JSON.stringify(sProductInfo);
      }
    }
  }
  return slaveSaveData;
}


/** 添加审核或者作废图标 */
export function handleAddIcon(props) {
  const { masterData } = props;
  let { imgSrc } = props;
  const { bInvalid, bCheck } = masterData;
  if (bInvalid) {
    imgSrc = imgInvalid;
  } else if (bCheck) {
    imgSrc = imgCheck;
  } else {
    imgSrc = '';
  }
  props.imgSrc = imgSrc;
  return props;
}

/* 上一条、下一条、首条、末条从表刷新 */
export function handleSlaveData(baseProps) {
  const { sTbName } = baseProps;
  let { subjectDataSave } = baseProps;
  if (sTbName === 'salsalesorderslave') {
    if (utils.isNotEmptyArr(baseProps.slaveData)) {
      subjectDataSave = handleSaveSlaveSaleOrder(subjectDataSave);
    }
  }
  baseProps.slaveData = [...subjectDataSave];
  if (utils.isNotEmptyArr(baseProps.slaveData)) {
    /*   重新做合计   */
    baseProps = handleAddDataTotal({ ...baseProps });
  }
  return baseProps;
}
